
import React, { Component } from 'react';
import ReactDOM from 'react-dom';

//=============导入高阶组件区=============
//1导入高阶组件,公共部分
import {createPage, base, ajax, high, toast, promptBox, deepClone} from 'nc-lightapp-front';
const {BillTrack} = high;
//2导入高阶组件, UIExtend的部分
import {Utils} from './Utils';

import ApproveDetail from 'uap/common/components/ApproveDetail';  //审批详情

//=============导入基础组件区=============
//1基础组件,公共部分
const {NCDiv, NCAffix, NCTabs, NCScrollElement} = base;
//2导入基础组件. UIExtend部分


//=============基本变量定义区=============
//1 基础常用变量声明部分
const EMPTY_FN = function(){}; //空函数

const URLS = {  // 请求路径
    flowEditableUrl: '/nccloud/arap/train/PFlowEditableTrainVOAction.do',//审批流可编辑字段请求路径
    loadUrl: '/nccloud/arap/train/LoadTrainVOAction.do'
};

const ACTIONS = {  // 按钮编码
	APPROVEDETAIL: 'ApproveDetail',  //审批详情
	BILLTRACK: 'BillTrack',  //单据追溯
	EXPANDLINE_OPR: 'ExpandLineOpr',    //操作列展开
    REFRESH: 'Refresh',  //刷新
	MORE: 'More'  // 更多
}

const FIELDS = {  // 字段编码
    APPROVESTATUS : 'approvestatus',
    BILLTYPE : 'billtype',
    TRANSTYPEPK: 'transtypepk',
    TRANSTYPE: 'transtype',
    BUSITYPE: 'busitype',
    CODE: 'code',
    PRIMARYKEY: 'pk_train'
}

//2 编辑模式变量
const EDITMODE_EDIT = 'edit';
const EDITMODE_BROWSE = 'browse';

//3 页面显示模式
//3.1 当前UIExtend需要定义的状态
const SHOWMODE_CARD = 'card';


const CARDTABLE_SUFFIX = 'Sub';  //卡片表格区域编码后缀

const BILLTYPE = 'ARAP01';

/****************************************************************************************************
 * 整体介绍：
 *      目前的这种写法是 单页应用的写法，多页面应用，页面切换时，采用的是“安装-卸载”的方式体现在render方法
 *      目前的这种写法，我们不需要再关注this指针的问题,也不需要在调用方法时使用call来切换指针并执行，直接"方法()"即可
 *      目前的这种写法，采用的是MVVM的架构模式，把state看做是VM，所以我们需要把目光集中在state
 * 
 *    本页面为审批中心详情页面。
 ****************************************************************************************************/

export class ApplicationPage extends Component{
	/**
	* 构造方法,js要求的必须方法,构造整个页面对象，
	* 此方法构造时，会定义全局配置，this.config,方便其他方法取用,
	* 同时，也处理了加载模板,按钮，设置模板按钮功能，最终通过调用
	* pageReady(此方法可以加入你的业务逻辑)完成第一次页面.
	* 此方法中,会调用initButton,initMeta来初始化模板和按钮,
	* initButton,initMeta,pageReady仅在页面打开时调用一次.
	* 其他时候不再调用
	*/
    constructor(props) {
        super(props); //构造
        
       // 节点全局变量定义
       //包含 页面编码定义,应用编码定义,标题定义,模块组件名定义
       //配置的获取方式，优先取平台定义,其次取传入配置定义, 最后默认
        this.config = {
            pagecode: props.getSearchParam('p')   || props.appcode || 'pagecode未定义', //页面编码定义
            appcode: props.getSearchParam('c')    || props.appcode || 'appcode未定义',  //应用编码定义
            title: this.props.getSearchParam('n') || props.title   || 'Demo主从表',     //表体定义
            moduleId: props.appcode,  //多语资源目录id
            domainName: 'arap' //模块域名
        }
        /**
         * 创建state,并构造节点模型,其结构与渲染时是一致的.
         * 可参照顶端代码注释的详细解释
         */
        this.state = this.createState();
        
        /**
         * 适配版本变化,2105及其以后版本必须的调用, 2之前版本不需要
         */
        this.props.use.form('trainForm');
        this.props.use.cardTable('train_bSub');
        
        /**
         * 加载NCC资源,
         * 1,包含单据模板,按钮,等平台定义的功能
         * 2,加载多语资源文件,
         * 3,加载需要在代码总用到参照js
         */
        Utils.loadNCCResource({
            props: props,
            referObjs: [],
            /**
             * 导入全局配置,加载资源时 appcode,pagecode,modulename等信息,
             * 需要用到,全局配置中包含所有它需要用到的参数,
             */
            ...this.config,
            //导入全局配置,
            callback: (data) => {
                let {context, template, button, lang, refer = {}} = data;
                /**
                 * 初始化模板,修改模板相关配置
                 * 初始化按钮,修改按钮相关配置,
                 * 并将模板配置,按钮配置输入到平台,通过setMeta,setButtons输入.
                 * 让平台进行初始化.当平台初始化完成后,通过then继续后续的工作
                 */
                template = this.initMeta(template); //更新模板
                button = this.initButton(button);
                Promise.all([//合并处理 模板 和 多语
                    new Promise(resolve => this.props.meta.setMeta(template, () => resolve(true))),
                    new Promise(
                        resolve => this.props.button.setButtons(button, () => resolve(true)))
                ]).then(() => {
                    this.setState({isPageReady: true}, () => {  //标记自己页面已经完成,并进行第一次的渲染
                        (this.pageReady || EMPTY_FN)();
                    });
                }).catch((e) => {
                    throw new ReferenceError(e);
                });
            }
        });
    }
    
    /**
     * pageReady方法为页面已经完全设置完毕，
     * 可以初始化一些初始的功能，比如查询下列表并显示数据等
     */
    pageReady = () => {
    	let scene = this.props.getUrlParam("scene");
        let id = this.props.getUrlParam("id");
        let status = this.props.getUrlParam("status");
        //let allpks = id instanceof Array ? id:[id];
		//this.state.allpks = allpks;
        if(!id){
			this.state.currentId = null;
        	toast({content: "系统错误，未传递联查pk！", color: 'danger'});
        	return;
        }
        
        this.state.currentId = id;
        this.setState(this.state, () => {
			this.loadCardData({billId : this.state.currentId,
				callback: ({data}) => { // data为查询结果
					//这里可以添加数据加载完成后的代码
					
				}
			});
		});
    }
    
    /**
      * 初始化平台定义的单据模板
      * 触发时机：执行loadNCCResource,加载完模板、多语、等初始化信息之后触发
      * 功能：对加载完的模板进行个性化调整
      * 可实现举例功能:
      * 1.参照表单联动过滤, 参见[Demo1] 
      * 2.处理表格操作列,   参见[Demo2]
      */
    initMeta = (meta) => {
        // 添加卡片行操作列
        meta['train_bSub'].items.push({
            attrcode: 'opr', // 列标识, 固定
            itemtype:'customer', // 列类型, 固定
            label: '操作', // 列名
            width: 200, // 列宽度
            className : 'table-opr', // 样式
            fixed: 'right', // 悬浮方向
            visible: true, // 是否可见
            render: (text, record, index) => { // 渲染方法
                let { editmode, card: {copiedArea, copiedRows}} = this.state;
                //获得符合条件按钮的key（编码）的集合
                let oprButtons = [];
                oprButtons.push('train_bSub_ExpandLineOpr');
                // 创建操作列API
                return this.props.button.createOprationButton(oprButtons, {
                    area: 'train_bSubOpr', // 按钮区域编码
                    buttonLimit: 3, // 允许的按钮最多显示数量
                    onButtonClick: (props, btncode) => this.onBtnClickFormlist(props, btncode, 'train_bSub', {data: record, index}) // 点击按钮
                });
            }
        });
		
		
        
    	meta['trainForm'].items.find(item => {
		
			// 云原生适配，saga开头的属性全部隐藏
			if (item.attrcode.startsWith('saga')) {
                item.visible = false;
                item.disabled = true;
            }
        });
		
		
        return meta;
    }
	
	
	/**
	 * 如果审批流配置了【流程字段权限设置】
	 * 则需要设置meta字段必填、可编辑性、可见性。
	*/
	modifyMetaForFlowConfig = ()=>{
		// 获取主键
        let billId = this.state.currentId;
		
		if(!billId){ return ; }//没有数据则直接返回

		//请求回调函数
		let onSuccess=(res)=>{
			if(!res||!res.data){//没有取到数据，原因是没有配置流程字段权限或当前环节没有配置
				return ;
			}
			let meta = this.props.meta.getMeta();//获取meta模板信息
			let areas = Object.keys(meta);//获取meta所有key
			areas.forEach(area=>{
				//如果不是区域则跳过
				if(!meta[area]||!meta[area].metaid||!meta[area].items){
					return;
				}
				meta[area].items.forEach(item=>{
					//关联元数据id
					let metaid = meta[area].metaid;
					//查找流程配置字段
					let flowConfig = res.data.find(config=>config.metaid == metaid && config.fieldcode == item.attrcode);
					if(!flowConfig){
						return ;
					}
					//isEdit是否可编辑，取值："Y"、"N"、"template"
					flowConfig.isEdit=='Y' && (item.disabled = false) || flowConfig.isEdit=='N' && (item.disabled=true);
					//isMust是否必输，取值："Y"、"template"
					flowConfig.isMust=='Y' && (item.required = true);
					//isVisible是否可见取值："Y"、"N"、"template"
					flowConfig.isVisible=='Y' && (item.visible = true) || flowConfig.isVisible=='N' && (item.visible=false);

				});
			});
			//重新设置meta
			this.props.meta.setMeta(meta);
		}
		
		//获取表单数据
		let formData = this.getCheckedDatas();
        let transtype = FIELDS.TRANSTYPE && formData && ( formData[0].values[FIELDS.TRANSTYPE].value);

		//后台请求
		ajax({
			//请求url
			url: URLS.flowEditableUrl,
			//请求参数
			data: { pk : billId,
				userJson:{billtype:transtype||BILLTYPE}
			},
			//请求结果，带着请求结果 执行回调函数
			success: res => onSuccess(res)
		})
	}
	
    /**
     * initButton方法 功能介绍：
     * 触发时机：执行loadNCCResource,加载完模板、多语、等初始化信息之后触发
     * 功能简介：对加载完的按钮数据进行个性化调整
     * 举例功能：
     * 1、禁用某按钮 参见Demo1
     */
    initButton = (button) => {
        /**
         * Demo1 处理按钮
         * 场景描述： 有时需要在按钮数据加载之后进行一些处理
         * 达成效果： 按钮不可见，并且禁用
         * 写法解释： 迭代所有按钮，找到Save按钮，设置按钮的可见性和禁用型
         * 代码示例:
         */
        //buttons.find(btn=>{//迭代buttons
        //  if(btn.key == 'Save'){//找到button的key为Save的按钮
        //      btn.disabled = true;//设置按钮禁用
        //      btn.visible = false;//设置按钮隐藏
        //  }
        //})
        return button;
    }
    /**
     * 创建state模型，具体方法功能介绍参考主应用里面的注释介绍。
     */
    createState = () => {
        let state = {
        	currentId : null,
        	allpks : [],//所有联查的pk
            isPageReady: false, // 页面是否可以渲染
            showmode: SHOWMODE_CARD, // 页面当前的显示模型
            editmode: EDITMODE_BROWSE, // 页面当前编辑模式
            head: {  // 节点标题栏
				title: "", // 标题，此处不显示标题。
				showPageIcon:false,//是否显示小应用图标
				initShowBackBtn: false, // 是否显示返回按钮 
            },
            headBtn: { // 头部按钮区
                area: 'common', // 区域编码
                onButtonClick: this.onBtnClickHead // 点击按钮
            },
            card: { // 卡片页面
                form: { // 表单
                    area: 'trainForm', // 区域编码
                },
                formlist: { // 子表表格
                    'train_bSub'/*区域编码*/: {
                        area: 'train_bSub', // 区域编码
                        showIndex: true, // 是否显示行序号
                        showCheck: true, // 是否显示多选框
                        adaptionHeight: true, // 是否自适应浏览器高度
                        onSelected: this.updateBtnStatus, // 点击选择框
                        onSelectedAll: this.updateBtnStatus, // 点击全选框
                        selectedChange: this.updateBtnStatus, // 选择框的选中行改变
                        hideModelSave: true,//隐藏整单保存按钮
                        hideAdd:true,//隐藏侧拉增行按钮
                        hideDel:true,//隐藏侧拉删行按钮
                        tableHead: () => this.state.card.formlist['train_bSub'].button.render(), // 肩部渲染，主要用于渲染肩部操作按钮，调用肩部按钮的渲染方法
                        button: { // 肩部按钮
                            area: 'train_bSub', // 区域编码
                            onButtonClick: (props, btnCode) => this.onBtnClickFormlist(props, btnCode, 'train_bSub'), // 点击按钮
                            render: () => { // 渲染方法
                                return (
                                    <div className="shoulder-definition-area">
                                        <div className="btn-group">
                                            {/*按钮*/}
                                            {this.props.button.createButtonApp(this.state.card.formlist['train_bSub'].button)}
                                        </div>
                                    </div>
                                );
                            }
                        },
                    }
                },
                copiedArea: '',
                copiedRows: [],
                cardPagniation: { // 翻页组件
                    visible: false, // 是否显示
                    handlePageInfoChange: this.onBtnClickCardPagniation // 点击翻页器按钮
                }
			}//card 
        };//state 
        
		
        // 审批详情
		Utils.apply(state, {
            approveDetail: { // 审批详情
                show: false,  //是否显示
                close: ()=>{ // 关闭事件回调函数
					this.state.approveDetail.show = false;
					this.setState(this.state);
				},
                billtype: BILLTYPE,  // 单据类型编码
                billid: null,  // 查询审批详情单据主键
            },
			billtrack: {  //单据追溯
                show: false,  //是否显示
                pk: null,  //显示的pk
                type: BILLTYPE,  //单据类型
                close: () => { // 关闭弹框
                    this.state.billtrack.show = false;
                    this.setState(this.state);
                }
            }//billtrack end
        });

		
        return state;
    }
    //4 渲染方法
    render() {
        let {isPageReady, showmode, head, headBtn, list, card} = this.state;
        if(!isPageReady) return ''; //页面资源加载完成后才能渲染页面
    	
		// 渲染卡片
        const renderCard = () => {
            let {form, formlist, cardPagniation} = card;
            if (showmode != SHOWMODE_CARD) {
                return '';
            }
            // cardtable存在bug，拷贝使用的是Object.assign()，会修改当前state
            let newFormlist = deepClone(formlist);
            let {'train_bSub' : tableConfig, ...other} = newFormlist;
            return (
                <div className='nc-bill-card'>
                    <div className="nc-bill-top-area">
                        <NCAffix>
                            <NCDiv areaCode={NCDiv.config.HEADER} className='nc-bill-header-area'>
                                <NCDiv areaCode={NCDiv.config.Title} className='header-title-search-area'>
                                    {this.props.BillHeadInfo.createBillHeadInfo(head)}
                                </NCDiv>
                                <div className="header-button-area">
                                    {this.props.button.createButtonApp(headBtn)}
                                </div>
                                <NCDiv areaCode={NCDiv.config.TABS} className='header-cardPagination-area' style={cardPagniation.visible ? {} : {display: 'none'}}>
                                    {this.props.cardPagination.createCardPagination(cardPagniation)}
                                </NCDiv>
                            </NCDiv>
                        </NCAffix>
                        <NCDiv areaCode={NCDiv.config.FORM} className="nc-bill-form-area">
                            {this.props.form.createForm(form.area, form)}
                        </NCDiv>
                    </div>
                    <div className="nc-bill-bottom-area">
                        <NCDiv areaCode={NCDiv.config.TABLE} className="nc-bill-table-area">
                            {this.props.cardTable.createCardTable(tableConfig.area, {...tableConfig, multiConfig: other})}
                        </NCDiv>
                    </div>
                </div>
            );
        };
        
		
		// 审批详情、单据追随
		const renderApproveInfo = () => {
            let {approveDetail,billtrack} = this.state;
            
            return (
                <div>
                    <ApproveDetail {...approveDetail}/>
                    <BillTrack {...billtrack} />
                </div>
            );
        }
        
      	return (
            <div>
                {renderCard()}
                {renderApproveInfo()}
            </div>
        );
      
      }//render
    
    //=============功能性方法区=============
    // 修改按钮状态
    // callback  回调
    updateBtnStatus = ({callback = EMPTY_FN} = {}) => {
        let { editmode, card: {formlist, copiedArea, copiedRows}} = this.state;
        let isBrowse = editmode == EDITMODE_BROWSE;
		let isCurrentId = this.state.currentId && true || false;
        let hasCopiedRows = Boolean(copiedArea);

        // 按钮可见性初始化
        let btnVisible = {
			[ACTIONS.APPROVEDETAIL]:isBrowse,
			[ACTIONS.BILLTRACK]:isBrowse,
			[ACTIONS.MORE]: isBrowse,
			[ACTIONS.REFRESH]: isBrowse
        }

        let btnDisabled = { 
			[ACTIONS.APPROVEDETAIL]: !isCurrentId,
			[ACTIONS.BILLTRACK]: !isCurrentId,
            [ACTIONS.REFRESH]: !isCurrentId,
        }
        
        let formlistBtnArea = Object.values(formlist).map(table => table.button.area);
        formlistBtnArea.forEach(btnAreaCode => {
            // 卡片子表按钮可见性
			btnVisible[btnAreaCode + '_ExpandLineOpr'] = true;

            // 卡片子表按钮可用性
            let cardTableCheckedRows = this.props.cardTable.getCheckedRows(btnAreaCode);
			btnDisabled[btnAreaCode + '_ExpandLineOpr'] = false;
        });
		
		this.props.button.setButtonVisible(btnVisible);
        this.props.button.setButtonDisabled(btnDisabled);
		// 设置卡片翻页器是否可见
        this.state.card.cardPagniation.visible =  editmode == EDITMODE_BROWSE;
        this.setState(this.state, callback);
    }
    
    updateCardStatus = ({areaInfo, editmode, callback = EMPTY_FN} = {}) => {
        // 设置卡片主表单为编辑态
        this.props.form.setFormStatus(areaInfo.formId, editmode);
        // 设置卡片子表表格为编辑态
        areaInfo.tableId.forEach(id => {
            this.props.cardTable.setStatus(id, editmode == EDITMODE_BROWSE ? EDITMODE_BROWSE : EDITMODE_EDIT);
        });
        setTimeout(callback, 0);
    }
    
	/**
    * 查询卡片数据
    * data:  查询参数
    *      billId  主键
    * callback  回调，(data: 查询结果，格式参考后端ExtBillCard类) => {}
	*/
    loadCardData = ({billId, callback = EMPTY_FN} = {}) => {
		// 获取卡片区域编码
        let areaInfo = this.getCardAreaCode();
        // 查询请求
        ajax({
            url: URLS.loadUrl,
            headers: this.ajaxHeader(),
            data: {
                pageCode: this.config.pagecode, // pagecode
                pk: billId, // 主键
                ...areaInfo // 区域编码
            },
            success: (res) => {
                let {data: {data} = {}} = res;
				// 填充卡片数据或清空卡片数据
				data ? this.fillCardData({data}) : this.clearCardData();
				// 更新按钮状态
				this.updateBtnStatus();
				// 加载并处理流程字段权限设置
				this.modifyMetaForFlowConfig();
				//回调函数
                callback({data});
            },
        });
    }
    

    /**
	* 填充卡片数据
    * data  卡片数据，格式参考后端ExtBillCard类
    * callback  回调，无参数
	*/
    fillCardData = ({data, callback = EMPTY_FN} = {}) => {
        // 获取卡片区域编码
        let area = this.getCardAreaCode();
        // 设置主表单数据
        this.props.form.setAllFormValue(data && data.head || {});
        // 设置子表表格数据
        area.tableId.forEach(id => {
            if (data && data.bodys && data.bodys[id]) {
                this.props.cardTable.setTableData(id, data.bodys[id], () => {
                });
            } else { // 子表没值则清空
                this.props.cardTable.setTableData(id, {rows: []});
            }
        });
        setTimeout(callback);
    }

    /**
    * 清空卡片数据
    * callback  回调，无参数
	*/
    clearCardData = ({callback = EMPTY_FN} = {}) => {
        // 获取卡片区域编码
        let area = this.getCardAreaCode();
        // 清空主表单数据
        this.props.form.EmptyAllFormValue(area.formId);
        // 清空子表表格数据
        area.tableId.forEach(id => {
            this.props.cardTable.setTableData(id, {rows: []});
        });
        setTimeout(callback);
    }
	
    

    // 获取卡片区域编码，包括主表单（formId）子表格（tableId），单表时没有tableId
    // 返回格式：{formId: '', tableId: ['']}
    getCardAreaCode = () => {
        return {
            tableId: Object.keys(this.state.card.formlist),
            formId: this.state.card.form.area
        }
    }
	
	/**
     * 方法功能： 获取表单数据
     * @returns {*[]|*} 返回选中行数组[{values:{itemcode:{value:'', display:''}}}, {values:{itemcode:{value:'', display:''}}}]
     */
    getCheckedDatas = () => {
		//解构参数
        let { card: {form}} = this.state;
		// 获取卡片主表单数据
		let checkedRow = this.props.form.getAllFormValue(form.area);
		// 结构为固定格式返回，主键必须有值，格式：[{values: {}}]
		return checkedRow && checkedRow.rows && checkedRow.rows[0].values[FIELDS.PRIMARYKEY].value ? checkedRow.rows : [];
        
    }
    
    
    /**
     * 按钮点击事件
     * @param props
     * @param btnCode  按钮id
     * @param param  列表操作列参数，适配操作列按钮
     */
    onBtnClickHead = (props, btnCode, param = {}) => {
        switch (btnCode) {
			case ACTIONS.APPROVEDETAIL://审批详情
				this.onApproveDetail();
				break;
			case ACTIONS.BILLTRACK://单据追溯
				this.onBillTrack();
				break;
            case ACTIONS.REFRESH: // 点击刷新
                this.onRefresh();
                break;
            default:
                break;
        }
    }
	
    
	/**
     * 方法功能：点击审批详情
     */
    onApproveDetail = () => {
        // 获取主键
        let billId = this.state.currentId;
		//获取表单数据
		let formData = this.getCheckedDatas();
        let transtype = FIELDS.TRANSTYPE && formData && ( formData[0].values[FIELDS.TRANSTYPE].value);
        let billtype = formData && formData[0].values[FIELDS.BILLTYPE].value || BILLTYPE;
        // 设置审批详情组件配置并显示
        this.state.approveDetail.show = true;
        this.state.approveDetail.billid = billId;
        // 没有交易类型传单据类型
        this.state.approveDetail.billtype = transtype || billtype;
        this.setState(this.state);
    }
	/**
     * 方法功能：
     *      单据追溯
     */
    onBillTrack = () => {
        
        // 设置单据追溯组件配置并显示
        this.state.billtrack.show = true;
        this.state.billtrack.pk = this.state.currentId;
        this.setState(this.state);
    }
	
	
	/**
     * 点击刷新按钮
     */
    onRefresh = () => {
        // 获取主键
        let billId = this.state.currentId;
        // 调用卡片查询方法，通过回调处理查询结果
		this.loadCardData({
			billId,
			callback: ({data}) => { // data为查询结果
				// 提示
				toast({color: 'success', content: '刷新成功'});
			}
		});
        
    }
	
    /**
     * 卡片翻页
     * @param props
     * @param nextId  下一个单据id
     */
    onBtnClickCardPagniation = (props, nextId) => {
		this.state.currentId = nextId;
        // 调用卡片查询方法，通过回调处理查询结果
        this.loadCardData({billId: nextId});
    }
    
    
	
    /**
     * 方法功能：
     *      卡片子表表肩按钮事件
     * @param props
     * @param btnCode  按钮id
     * @param tableId  表格id
     */
    onBtnClickFormlist = (props, btnCode, tableId, row) => {
        // 卡片子表表肩符合以_AddLine结尾的规范，根据后缀判断按钮功能
        let lastIndex = btnCode.lastIndexOf("_");
        let code = btnCode.substr(lastIndex + 1);
        switch (code) {
            case ACTIONS.EXPANDLINE_OPR://展开
                this.onCardTableExpandLine(tableId, row);
                break;
            default:
                break;
        }
    }
	
	
	
	onCardTableExpandLine = (tableId, row) => {
        let {editmode} = this.state;
        let status = editmode == EDITMODE_BROWSE ? EDITMODE_BROWSE : EDITMODE_EDIT;
        this.props.cardTable.openModel(tableId, status, row.data, row.index, () => {});
    }
	
	
    
	ajaxHeader = () => {
        const {context = {}, card} = this.state;
        const {form} = card;
        const {paramMap = {}} = context;
        const {node} = paramMap;
        let pk_org;
        pk_org = this.props.form.getFormItemsValue(form.area, FIELDS.PK_ORG);
        pk_org = pk_org && pk_org.value || '';
        return {
            node: node,
            pk_org: pk_org,
        };
    }

    
}

const config = {
    title: '培训单据审批',
    pagecode: '20060420P_train',
    appcode: '20060420P',
    domainName: 'arap'
};
ApplicationPage = createPage({
    initTemplate:{},
    billinfo: {
        billtype: 'extcard',
        pagecode: '20060420P_train',
        headcode: 'trainForm',
        bodycode: ['train_bSub']
    }
})(ApplicationPage);

ReactDOM.render(<ApplicationPage {...config}/>, document.querySelector("#app"));
